# check if filter paths are valid
        if self.cfg.track_contact_points or self.cfg.track_friction_forces:
            if len(self.cfg.filter_prim_paths_expr) == 0:
                raise ValueError(
                    f"The 'filter_prim_paths_expr' is empty. Please specify a valid filter pattern to track"
                    f" {'contact points' if self.cfg.track_contact_points else 'friction forces'}."
                )
            if self.cfg.max_contact_data_count_per_prim < 1:
                raise ValueError(
                    f"The 'max_contact_data_count_per_prim' is {self.cfg.max_contact_data_count_per_prim}. "
                    f"Please set it to a value greater than 0 to track"
                    f" {'contact points' if self.cfg.track_contact_points else 'friction forces'}."
                )

        # reset contact positions
        if self.cfg.track_contact_points:
            self._data.contact_pos_w[env_ids, :] = torch.nan
        # reset friction forces
        if self.cfg.track_friction_forces:
            self._data.friction_forces_w[env_ids, :] = 0.0

    def _unpack_contact_data(
        self,
        contact_data: torch.Tensor,
        buffer_count: torch.Tensor,
        buffer_start_indices: torch.Tensor,
        avg: bool = True,
        default: float = float("nan"),
    ) -> torch.Tensor:
        """
        Unpacks and aggregates contact data for each (env, body, filter) group.

        This function vectorizes the following nested loop:

        for i in range(self._num_bodies * self._num_envs):
            for j in range(self.contact_physx_view.filter_count):
                start_index_ij = buffer_start_indices[i, j]
                count_ij = buffer_count[i, j]
                self._contact_position_aggregate_buffer[i, j, :] = torch.mean(
                    contact_data[start_index_ij : (start_index_ij + count_ij), :], dim=0
                )

        For more details, see the RigidContactView.get_contact_data() documentation:
        https://docs.omniverse.nvidia.com/kit/docs/omni_physics/107.3/extensions/runtime/source/omni.physics.tensors/docs/api/python.html#omni.physics.tensors.impl.api.RigidContactView.get_net_contact_forces

        Args:
            contact_data (torch.Tensor): Flat tensor of contact data, shape (N_envs * N_bodies, 3).
            buffer_count (torch.Tensor): Number of contact points per (env, body, filter), shape (N_envs * N_bodies, N_filters).
            buffer_start_indices (torch.Tensor): Start indices for each (env, body, filter), shape (N_envs * N_bodies, N_filters).
            avg (bool, optional): If True, average the contact data for each group; if False, sum the data. Defaults to True.
            default (float, optional): Default value to use for groups with zero contacts. Defaults to NaN.

        Returns:
            torch.Tensor: Aggregated contact data, shape (N_envs, N_bodies, N_filters, 3).
        """
        counts, starts = buffer_count.view(-1), buffer_start_indices.view(-1)
        n_rows, total = counts.numel(), int(counts.sum())
        agg = torch.full((n_rows, 3), default, device=self._device, dtype=contact_data.dtype)
        if total > 0:
            row_ids = torch.repeat_interleave(torch.arange(n_rows, device=self._device), counts)

            block_starts = counts.cumsum(0) - counts
            deltas = torch.arange(row_ids.numel(), device=counts.device) - block_starts.repeat_interleave(counts)
            flat_idx = starts[row_ids] + deltas

            pts = contact_data.index_select(0, flat_idx)
            agg = agg.zero_().index_add_(0, row_ids, pts)
            if avg:
                agg = agg / counts.clamp_min(1).unsqueeze(-1)
            agg[counts == 0] = default

        return agg.view(self._num_envs * self.num_bodies, -1, 3).view(
            self._num_envs, self._num_bodies, self.contact_physx_view.filter_count, 3
        )

    friction_forces_w: torch.Tensor | None = None
    """Sum of friction forces between sensor body and filter prim in world frame.

    Shape is (N, B, M, 3), where N is the number of sensors, B is number of bodies in each sensor
    and M is the number of filtered bodies.

    Collision pairs not in contact will have zero friction forces.

    Note:

        * If the :attr:`ContactSensorCfg.track_friction_forces` is False, then this quantity is None.
        * If the :attr:`ContactSensorCfg.filter_prim_paths_expr` is empty, then this quantity is an empty tensor.
        * If the :attr:`ContactSensorCfg.max_contact_data_per_prim` is not specified or less than 1, then this quantity
          will not be calculated.
    """